home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Tele / C / Comet2.1.3 Folder / Comet / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-22  |  38.2 KB  |  1,824 lines  |  [TEXT/????]
  1. /*
  2.     Copyright Cornell University 1986.  All rights are reserved.
  3. */
  4.  
  5.  
  6. /***************************************************************************
  7. **     3270 Driver  initializations, main program, & error handler        **
  8. ****************************************************************************
  9. **     Developed at Cornell University by:                                  **
  10. **     Richard Cogger, Peter Hoyt, Kevin Saunders, & John Lynn              **
  11. **     includes calls to TCP, IP, and tasking routines developed at MIT   **
  12. ***************************************************************************/
  13.  
  14. /* tn3270.c contains the main() loop and various support routines */
  15.  
  16. #ifdef MULTI
  17.             /* multiple windows version */
  18.             
  19. #include    <em.h>
  20.  
  21. #include    <cntl.h>
  22. #include    <key.h>
  23. #include    <macdefs.h>
  24. #include    <h19.h>
  25. #include    <timer.h>
  26. #include    <ft.h>
  27.  
  28. #include    <3270.h>                       /* external variables & constants     */
  29. #include    <cntldefs.h>
  30. #include    <resdefs.h>
  31. #include    "xlate.h"
  32. #include    "menudefs.h"
  33. #include    "tftp.h"
  34.  
  35. #ifdef DUALTCP
  36.  
  37. #include    <net.h>        /* NEW merged TCP drags in task.h */
  38. #else
  39.  
  40. #include    <net.h>        /* NEW merged TCP drags in task.h */
  41. #include    <q.h>        /* TODO should be different with MACTCP alone */
  42. extern char timertripped;        /* the timer requires service */
  43. #endif
  44.  
  45. #else
  46.  
  47. #ifdef MACTCP
  48. #include    <q.h>
  49. #else
  50. #include    <tcp.h>
  51.  
  52. #endif
  53.  
  54. #include    <stdio.h>
  55.  
  56. #include    <osutil.h>
  57. #include    <quickdraw.h> 
  58. #include    <resource.h> 
  59. #include    <toolutil.h>
  60. #include    <window.h>
  61. #include    <control.h>
  62. #include    <font.h> 
  63. #include    <event.h>
  64. #include    <desk.h>
  65. #include    <packages.h>
  66. #include    <segment.h>
  67.  
  68. #include    <menu.h>
  69. #include    <dialog.h>
  70. #include    <memory.h>
  71.  
  72. #include    <cntl.h>
  73. #include    <key.h>
  74. #include    <macdefs.h>
  75. #include    <h19.h>
  76. #include    <timer.h>
  77. #include    <emdefs.h>
  78. #include    <telnet.h>
  79. #include    <ft.h>
  80.  
  81. #include    <3270.h>                       /* external variables & constants     */
  82. #include    <cntldefs.h>
  83. #include    <resdefs.h>
  84. #include    "xlate.h"
  85. #include    "menudefs.h"
  86. #include    "tftp.h"
  87.  
  88. #endif
  89.  
  90.  
  91.  
  92. #ifdef DUALTCP
  93. #undef MACTCP
  94. /* make both tcps in one package */
  95. #endif
  96.  
  97.  
  98. struct winds * conns[MAXWIND];
  99. short conncount;
  100.  
  101. /* true globals */
  102.  
  103. #ifdef MULTI
  104. struct winds * emdp;            /* pointer to connection block we're using */
  105. struct winds * keydp;            /* pointer to top window connection block we're using */
  106. #endif
  107.  
  108. short mfbackonly;                /* run whole app only in background */
  109.  
  110. WindowPtr    keywindow;            /* the active window, emwindow or textwindow */ 
  111. WindowPtr    iconwindow;            /* top go-away window, shows tn3270 icon */
  112. WindowPtr    emwindow;            /* the current output emulator window */ 
  113.  
  114. #ifdef USEHELPWINDOW
  115. /* help window vars */
  116. WindowPtr    helpwindow;            /* there is one help window */ 
  117. struct windtext helptext;
  118. struct windtext {
  119.     TEHandle    texthand;                /* with a TextEdit box and a scrollbar */ 
  120.     int            FirstLine;                /* the number of the line at the top */
  121.     short         textscrapped;            /* the TE scrap has been touched and must be coerced */
  122.     short         textlines;                /* # of lines in page */
  123.     ControlHandle scrollhand;            /* scroll bar control */
  124. }
  125. #endif
  126.  
  127. EventRecord    myEvent;
  128.  
  129. short courierprint;                    /* print using Courier on LaserWriters? */
  130. short appresfid;                    /* application resource file descriptor */
  131. short appvol;                        /* application home volume */
  132. long appdir;                        /* application home directory */
  133. short appvref;                        /* application volume ref num */
  134.  
  135. char * setfile = "\PComet Default";            /* system folder settings default filename */
  136.  
  137. short quitonclose;                    /* user wants app to close when no windows */
  138.  
  139. /* connection management */
  140. short connavailable;            /* an empty connection struct is lying about */
  141.  
  142. /* TCP vars */
  143. short cutcpopen;                /* Cornell TCP has been opened */
  144. short macipopen;                /* macTCP has been opened */
  145. short mactcpopen;                /* macTCP has been opened */
  146. short mtevent;                    /* MacTCP--new data or control info has arrived */
  147.  
  148. short mtcpsendasync;            /* use async send w/ MacTCP */
  149.  
  150. short tftpopen;                    /* has tftp been initialized? */
  151. short tftpserve;                /* act as a tftp server */
  152. short tftpask;                    /* query user about transfers */
  153.  
  154. short trydsdraw;                /* *try* to use direct to screen drawing */
  155. short riskydsdraw;                /* only use dsdraw in FrontWindow() */
  156.  
  157. PicHandle shrinkpict;            /* picture for shrink control */
  158. PicHandle tapepict;                /* picture of cassette tape */
  159.  
  160. short icon_up;                    /* iconwindow is up for top window */
  161.  
  162. long long1;                        /* useful storage for assembly routines */
  163. long long2;
  164. long long3;
  165. long long4;
  166.  
  167. TEHandle helptehand;
  168. WindowPtr helpwind;
  169. long filltimeout;
  170.  
  171. /* mouserect sizing and tracking of cursor */
  172.  
  173. short  trackon;                    /* flag for cursor tracking on */
  174. Rect mouserect;                    /* also used by h19curset to find the targeted x,y */
  175. short inemulator;                /* an emulator is in use */
  176. short clickdelay = 10;            /* # of ticks to wait before setting a selection */
  177.  
  178. /* Cursors */
  179.  
  180. Rect    cursrect;                /* inviolable cursor Rect */
  181. short    curson;                    /* cursor state on or off */
  182. Cursor    blank = { 
  183.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  184.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  185.     8, 8 };
  186. Cursor * thecursor = ␣
  187. Rect    zaprect;                /* for ShieldCursor */
  188. SysPtr    paramptr;                /* pointer to parameters for cursor blink time */
  189. unsigned long    cursalarm;        /* tick count at which to change cursor */
  190. RgnHandle emclip;                /* holds previous em clip rect */
  191. RgnHandle q3clip;                /* for calculating new clip w/o q3 box */
  192.                                 
  193.  
  194. /* q3 control globals */
  195. short q3conth;                    /* height of quadrant 3 control button */
  196. short q3contskip;                /* size of skip every 3 buttons */
  197. Rect boxrect;                /* box in which the q3 button labels are drawn */
  198.  
  199. /* character images for direct to screen drawing */
  200.  
  201. FONTS    font;                    /* normal font */
  202. FONTS    invfont;                /* inverted */
  203. FONTS    boldfont;                /* bold font */
  204. FONTS    invboldfont;            /* inverted */
  205. FONTS    bvtfont;                /* vt font */
  206. FONTS    invbvtfont;                /* inverted */
  207.  
  208. short * chofftab9;                /* array of character offsets to avoid multiplies */
  209. short * chofftab12;                /* array of character offsets to avoid multiplies */
  210.  
  211. RgnHandle updateRgn;            /* rgn for scroll update regions */
  212.  
  213. short bkrd_act = 1;                /* is tcp running in background mode? */
  214.  
  215. Rect dragrect;                    /* the drag rectangle for all windows */
  216.  
  217. /* we use a bit array to mark dirty lines a` la zapchar, here are the masks */
  218.  
  219. unsigned long modmask[32] = {
  220.     0x00000001L,
  221.     0x00000002L,
  222.     0x00000004L,
  223.     0x00000008L,
  224.     0x00000010L,
  225.     0x00000020L,
  226.     0x00000040L,
  227.     0x00000080L,
  228.     0x00000100L,
  229.     0x00000200L,
  230.     0x00000400L,
  231.     0x00000800L,
  232.     0x00001000L,
  233.     0x00002000L,
  234.     0x00004000L,
  235.     0x00008000L,
  236.     0x00010000L,
  237.     0x00020000L,
  238.     0x00040000L,
  239.     0x00080000L,
  240.     0x00100000L,
  241.     0x00200000L,
  242.     0x00400000L,
  243.     0x00800000L,
  244.     0x01000000L,
  245.     0x02000000L,
  246.     0x04000000L,
  247.     0x08000000L,
  248.     0x10000000L,
  249.     0x20000000L,
  250.     0x40000000L,
  251.     0x80000000L
  252. };
  253.  
  254. char zapuline;                    /* flag to zapchar to underline character */
  255. char zapinvert;                    /* flag to zapchar to underline character */
  256.  
  257. char inselection;                /* flag that we are in selection range */
  258.  
  259. char skiparr[NOCHARS];            /* chars which are blank & can be skipped */
  260. char allskiparr[NOCHARS];        /* alternate all-TRUE skiparr */
  261.  
  262. short keyboard = PLUSKEYBOARD;    /* keyboard type */
  263. short keypadswitch;                /* switch SE keypad */
  264.  
  265. /* a default ibmcolormap */
  266.  
  267. struct ibmcolormap ibmcolormap = {
  268.                                                 /* unprotected ... */
  269.     0, 0, 0,             65535, 65535, 65535,    /* normal (black on white) */
  270.     50000, 1000, 1000,     65535, 65535, 65535,    /* sense (red on white) */
  271.     0, 0, 0,             65535, 65535, 65535,    /* intense (black on white) */
  272.     0, 0, 0,             65535, 65535, 65535,    /* invis (black on white) */
  273.  
  274.                                                 /* protected ... */
  275.     0, 0, 0,             65535, 65535, 65535,    /* normal (black on white) */
  276.     50000, 1000, 1000,     65535, 65535, 65535,    /* sense (red on white) */
  277.     0, 0, 0,            65535, 65535, 65535,    /* intense (black on white) */
  278.     0, 0, 0,             65535, 65535, 65535        /* invis (black on white) */
  279. };
  280.  
  281. struct ibmcolormap asccolormap = {
  282.     0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF,        /* normal (black on white) */
  283.     0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000,        /* reverse (white on black) */
  284.     0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF,        /* bold (red on white) */
  285.     0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000,     /* bold reverse (white on red) */
  286.  
  287.                                                         /* blink ... */
  288.     0x0000, 0x0000, 0x0000, 0xFF70, 0xFFFF, 0x3752,     /* black on yellow */
  289.     0xFF70, 0xFFFF, 0x3752, 0x0000, 0x0000, 0x0000,     /* rev: Yellow on black */
  290.     0xFFFF, 0x0000, 0x0000, 0xFF70, 0xFFFF, 0x3752,     /* bold: red on yellow */
  291.     0xFF70, 0xFFFF, 0x3752, 0xFFFF, 0x0000, 0x0000,     /* boldrev: yellow on red */
  292. };
  293.  
  294. /* TODO ideally the strings and actions associated with the 3rd quadrant buttons
  295.     would be reconfigurable on a per-window basis... */
  296.     
  297. char * q3strings[] = {
  298.     "PF1",
  299.     "PF2",
  300.     "PF3",
  301.     "PF4",
  302.     "PF5",
  303.     "PF6",
  304.     "PF7",
  305.     "PF8",
  306.     "PF9",
  307.     "PF10",
  308.     "PF11",
  309.     "PF12",
  310.     "PF13",
  311.     "PF14",
  312.     "PF15",
  313.     "PF16",
  314.     "PF17",
  315.     "PF18",
  316.     "PF19",
  317.     "PF20",
  318.     "PF21",
  319.     "PF22",
  320.     "PF23",
  321.     "PF24",
  322.     
  323.     /* VT52/VT100 labels */
  324.     "KP 1",
  325.     "KP 2",
  326.     "KP 3",
  327.     "KP 4",
  328.     "KP 5",
  329.     "KP 6",
  330.     "KP 7",
  331.     "KP 8",
  332.     "KP 9",
  333.     "KP 0",
  334.     "KP -",
  335.     "KP , (+)",
  336.     
  337.     "PF1 (Gold)",
  338.     "PF2 (Help)",
  339.     "PF3",
  340.     "PF4",
  341.     "KP .",
  342.     "KP Enter",
  343.     "Find",
  344.     "Insert Here",
  345.     "Remove",
  346.     "Select",
  347.     "Prev Screen",
  348.     "Next Screen"
  349. };
  350.     
  351. /* for ASCII vt100 mode */
  352.             
  353. char q3vtcontrols[] = {
  354. 'q',
  355. 'r',
  356. 's',
  357. 't',
  358. 'u',
  359. 'v',
  360. 'w',
  361. 'x',
  362. 'y',
  363. 'p',
  364. 'm',
  365. 'l',
  366.  
  367. 'P',
  368. 'Q',
  369. 'R',
  370. 'S',
  371. 'n',
  372. 'M',
  373. '1',
  374. '2',
  375. '3',
  376. '4',
  377. '5',
  378. '6'
  379. };
  380.  
  381. /* for ASCII mode */
  382.             
  383. char q3controls[] = {
  384. 'S',
  385. 'T',
  386. 'U',
  387. 'V',
  388. 'W',
  389. 'X',
  390. 'Y',
  391. 'Z',
  392. '[',
  393. 'P',
  394. 'Q',
  395. 'R'
  396. };
  397.  
  398. char * nosessionstr = "Session closed";
  399. char * hostwait = "Connecting to host...";
  400. char * badaddress = "Invalid host address";
  401.  
  402.  
  403. /* BIGG preserve as globals for better speed */
  404.  
  405. /* shared BIGG */
  406.  
  407. /* used by dsdraw zap.asm routines */
  408.  
  409. FONTS *thefont;                    /* BIGG */
  410. short xpos, ypos;                /* BIGG current x, y position */
  411. unsigned long modflg;            /* BIGG line modified bit array */
  412. unsigned long clrflg;            /* BIGG line cleared bit array */
  413. short fontwidth;                /* BIGG width of font */
  414. short ** startarr;                /* BIGG dsdraw -> array of ptrs to scanline starts */
  415. short screenbytes;                /* BIGG width of screen in bytes */
  416. short screenrem;                /* BIGG screenbytes - std screen */
  417. char * skiptest;                /* current skip array to use in zap */
  418.     
  419. /* h19 BIGG */
  420. short mode;                        /* BIGG interpretation mode of emulator */
  421. unsigned char * charp;            /* BIGG cursor loc for these arrays */
  422. short inserton;                    /* BIGG insert mode */
  423. short linelength;                /* BIGG width of row */
  424. short lastcol;                    /* BIGG linelength - 1 */
  425. unsigned char attrib;            /* BIGG normal/reverse mode for copy drawing */
  426.  
  427. short wrap_around;                /* BIGG wrap at end of line if true */
  428.  
  429. /* vt100 BIGG */
  430.  
  431. short vtmode;                    /* BIGG new mode holder for vt100 */
  432. unsigned short * argp;            /* BIGG -> current argument */
  433.  
  434. /* 3270 BIGG */
  435. short cmdstate;                    /* BIGG state of the emulator */
  436. unsigned char *scr_map;            /* BIGG screen map */
  437. unsigned char *smap_end;        /* BIGG end of map */
  438. unsigned char *current_attr;    /* BIGG pointer to most recent attribute */
  439. unsigned char *cursor_ptr;        /* BIGG current cursor position in screen map */
  440. unsigned char * firstp;            /* BIGG ptr to first data byte processed for set_map */
  441.  
  442.  
  443.  
  444.  
  445. /* end BIGG vars */
  446.  
  447.  
  448.  
  449. #ifdef MACTCP
  450. unsigned NDEBUG = TRUE;                /* stupid debug flag */
  451. struct net thisnet;
  452. struct net * rnet;
  453. short nnrup;                        /* network not responding dialog up */
  454. struct task * tk_cur;                    /* subs for current task ptr */
  455. short iplog;
  456.  
  457. extern int tcpwr_usr();            /* these are now stubs for compatibility */
  458. extern int tcpmst_run();
  459. extern int tcpopn_usr();
  460. extern int tcpcls_usr();
  461. extern int tcptmo_usr();
  462. extern int tcppr_dot();
  463. extern int tcpbfr();
  464.  
  465. #else
  466.  
  467. extern int tcpwr_usr();
  468. extern int tcpmst_run();
  469. extern int tcpopn_usr();
  470. extern int tcpcls_usr();
  471. extern int tcptmo_usr();
  472. extern int tcppr_dot();
  473. extern int tcpbfr();
  474. #endif
  475.  
  476.  
  477. unsigned long tickserial;    /* next tick count to service serial port */
  478. short serialwait;            /* how long the serial mgr thinks we should wait */
  479. unsigned long tickcursor;    /* next tick count to service cursor */
  480. unsigned long tickstats;    /* next tick count to display packet counters */
  481. extern short modaldialog;
  482.  
  483.  
  484. int proc_token();
  485. int nullputchar();
  486. int nullputflush();
  487.  
  488. short edresetselect;            /* reset selection after emulator edit action */
  489.  
  490. char isdiacritic[NOCHARS];    /* marks 0-width diacritical characters for screen drawing */
  491.  
  492.  
  493. /* NEW CU TCP/ MacTCP merge features */
  494.  
  495. struct winds * tcpemdp;        /* the window context in which CU tcp runs */
  496.  
  497.  
  498.  
  499. #ifdef KEEPALIVE
  500.  
  501. timer *tel_ayt;
  502. #define AYTT 500       /* seconds between ayt tickles */
  503. extern int            beep_ayt();
  504.  
  505. #endif
  506.  
  507.  
  508.  
  509.  
  510. main()
  511. {
  512. #ifdef MACTCP
  513.     rnet = &thisnet;
  514. #else
  515. #asm
  516.     public _appstak
  517.     move.l a6,_appstak ;    /* set the stack bottom ptr to copy the whole stack */
  518. #endasm
  519. #endif
  520.  
  521.     A5init();                    /* save a5 */
  522.     macinit((long) (75L * 1024L));
  523.     setupapplemenu();        /* so we can chk for multifinder */
  524.     if (chkmultifinder()) {
  525.         EventRecord myEvent;
  526.         
  527.         /* eventavail will put these back on the queue, but not just any event! */
  528.         EventAvail(keyDownMask, &myEvent);
  529.         EventAvail(keyDownMask, &myEvent);
  530.         EventAvail(keyDownMask, &myEvent);
  531.             /* these calls will prompt the MultiFinder to display our startup screen */
  532.     }
  533.     if (!scrinit()) {
  534.         error("Can't initialize screen");
  535.         cu_exit(-1);
  536.     }
  537.  
  538.     tn_init();
  539.     ibm_init();
  540.     setupmenu();
  541.  
  542.     SetEventMask(everyEvent);
  543.         /* fix event mask for autokeycommand--may cause full event queue! */
  544.  
  545. #ifdef DOHYC
  546.     hyc_init();
  547. #endif
  548.  
  549. /* and some optional stuff */
  550.  
  551. #ifdef KEEPALIVE
  552.     if ((tel_ayt = tm_alloc()) == NULL) {
  553.         error("Unable to allocate telnet ayt timer");
  554.         cu_exit(-1);
  555.     }
  556.     tm_set(AYTT, beep_ayt, NULL, tel_ayt);
  557. #endif
  558.  
  559. #ifdef MACTCP
  560.     tk_cur = 2L;                /* needs to be nonzero so tk_yield will be called */
  561.     tm_init();
  562. #else
  563.     /* initialize tasking */
  564.     tk_init(10000);                /* size of the main task's stack */
  565.     tm_init();
  566. #endif
  567.  
  568.     /* open document files & do configuration  */
  569.     openlaunchres();    
  570.     
  571.     fillwindclose();
  572.         /* close the copyright window if it's up */
  573.  
  574. #ifdef TFTPSERVE
  575.     /* start the tftp server and turn it on if configured on */
  576.     if (tftpserve == TFYES) {
  577.         tfs_on();
  578.     }
  579. #endif
  580.     /* and now we run ... */
  581.     while (TRUE) {
  582.         
  583.         user_act();            /* user input--process mac events */
  584.  
  585.         token_service();    /* user output--handle actions waiting on the queue */
  586.         io_service();        /* for merged MacTCP/CUTCP */
  587.         screen_service();    /* update screen */
  588.  
  589. #ifdef DUALTCP
  590.         tk_yield();            /* task yield for Cornell TCP */
  591. #else
  592.         if (timertripped)
  593.             tm_main();        /* service timer */
  594. #endif
  595.     }
  596.     /* not reached */
  597.     cu_exit(0);
  598. }
  599.  
  600.  
  601. /*  some trivial subroutines that interact with lower level code  */
  602.  
  603. #ifdef KEEPALIVE
  604.  
  605. /*  set a flag when timer pops (should just send an AYT!) */
  606.  
  607. beep_ayt() 
  608. { 
  609.     emdp->event_reg |= TICKLE;
  610. }
  611.  
  612. #endif
  613.  
  614. /* figure out a neat telnet socket */
  615.  
  616. tn_sock() 
  617. {
  618.     long temp;
  619.  
  620.     GetDateTime(&temp);
  621.     temp &= 0xffff; 
  622.     if (temp < 1000) 
  623.         temp += 1000;
  624.     return((unsigned) temp);
  625. }
  626.  
  627.  
  628. /* called when a connection is opened to perform UI tasks */
  629.  
  630. opn_usr() 
  631. {
  632.     emdp->connopen = TRUE;
  633.  
  634.     emdp->hycconnwait = FALSE;
  635.     if (emdp->emwindow != NULL) {
  636.         /* update the menus; first the window menu mark */
  637.         if (emdp->conntype == CONN_MACTCP || emdp->conntype == CONN_CUTCP) {
  638.             windmenumark(emdp, 0xA5);        /* set a • mark */
  639.         }
  640.         else if (emdp->conntype == CONN_SERD) {
  641.             windmenumark(emdp, emdp->usebport ? '-' : '+');        
  642.                 /* set a mark on the menu item + for modem port,
  643.                     - for printer port */
  644.         }
  645.         else if (emdp->conntype == CONN_COMMMGR) {
  646.             windmenumark(emdp, 0xA5);        /* set a • mark */
  647.         }
  648.         
  649.         if (keydp == NULL || emwindow == keydp->emwindow) {
  650.             if (setmsession(emdp) || setmenuconn(emdp))
  651.                 DrawMenuBar();
  652.         }
  653.         restore25();    /* allow controls to be drawn */
  654.     }
  655. }
  656.  
  657.  
  658. /* called when a session is closed, window menu mark already set */
  659. /* WARNING: twp may disappear, emdp may change! */
  660.  
  661.  
  662. cls_usr() 
  663. {
  664.     if (!emdp->connopen)
  665.         return;
  666.         
  667.     if (emdp->hycactive)
  668.         emdp->hycconnwait = FALSE;
  669.  
  670.     emdp->connopen = FALSE;
  671.     emdp->termset = FALSE;            /* no terminal type selected */
  672.     emdp->event_reg = 0;
  673.     emdp->in_cnt = 0;
  674.     emdp->out_cnt = 0;
  675.     flushactions(emdp);
  676.     
  677.     savescreen();            /* in case we're logging the session */
  678.     logclose();
  679.     
  680.     if (emdp->emwindow != NULL) {
  681.         
  682.         if (!line25on(emdp))
  683.             pr25(0, nosessionstr);
  684.         status_info();
  685.         /* prettywind(TRUE); 
  686.             results in cleared area when color is on */
  687.         if (keydp == NULL || emdp->emwindow == keydp->emwindow) {
  688.             /* fix menu to reflect status */
  689.             if (setmsession(emdp) || setmenuconn(emdp))
  690.                 DrawMenuBar();
  691.         }
  692.         if (emdp->disposeonclose) {
  693.             /* kill window when closed */
  694.             queryclosewind(emdp);
  695.         }
  696.     }
  697. }
  698.  
  699. tcpmst_run()
  700. {
  701. }
  702.  
  703.  
  704. /* call wr_usr after getting the context */
  705.  
  706. tcpwr_usr(buf, len, urg)
  707. unsigned char *buf;
  708. int len;
  709. int urg; 
  710. {
  711.     struct winds * oemdp;
  712.     
  713.     oemdp = emdp;
  714.     getcontext(tcpemdp);
  715.     wr_usr(buf, len, urg);
  716.     
  717.     if (emdp == oemdp)
  718.         emdp->modflg = modflg;
  719.         /* needs to be updated even if no context change so screen_service can
  720.             pick up the changes */
  721.     else
  722.         getcontext(oemdp);
  723. }
  724.  
  725. /* call opn_usr after getting the context */
  726.  
  727. tcpopn_usr()
  728. {
  729.     struct winds * oemdp;
  730.     
  731.     oemdp = emdp;
  732.     getcontext(tcpemdp);
  733.     opn_usr();
  734.     getcontext(oemdp);
  735. }
  736.  
  737. /* call cls_usr after getting the context */
  738.  
  739. tcpcls_usr()
  740. {
  741.     struct winds * oemdp;
  742.     
  743.     tcpemdp->closeflag = TRUE;
  744.     mtevent = TRUE;
  745. }
  746.  
  747.  
  748. /* make a new connection, do user dialog to configure it, and connect */
  749.  
  750. newconn()
  751. {
  752.     if (makeconn())
  753.         return(-1);
  754.  
  755.     opensettings();
  756.     getconfig();                /* do first, namewindow response may override */
  757.     releaseconfig();            /* release handles, which we don't want to use */
  758.     
  759.     if (namewindow()) {
  760.         closesettings();
  761.         killconn();
  762.         return(-1);
  763.     }
  764.  
  765.     emdp->newconf = TRUE;        
  766.         /* it's a new, unopened file even if "Untitled" unchanged */
  767.  
  768.     setappfilename();
  769.     
  770.     if (makewind()) {
  771.         closesettings();
  772.         killconn();
  773.         return(-1);
  774.     }
  775.     
  776.     emdp->resfid = 0;
  777.     setwindvols(emdp);            /* set default directories */
  778.     
  779.     closesettings();
  780.  
  781.     emdp->keyxhead = NULL;        /* don't inherit key resources */
  782.  
  783.     restore25();
  784.     addwindmenu(emdp->emwindow);
  785.  
  786.     openconn(emdp);
  787.     
  788.     return(0);
  789. }
  790.  
  791.  
  792. /* make a new connection structure, initialize vt100 */
  793.     
  794. makeconn()
  795. {
  796.     struct winds * otwp;
  797.     struct timer * otimer;
  798.     
  799.     if (conncount >= MAXWIND)
  800.         return(-1);
  801.  
  802.     if (connavailable) {
  803.         /* emdp is the only connection block lying around,
  804.             no window, no connection */
  805.         connavailable = FALSE;
  806.         emedit(emdp, TRUE);
  807.         
  808.         /* save things from the old structure */
  809.         otimer = emdp->token_tm;
  810.         memzero(emdp, sizeof(struct winds));
  811.             /* zero out the new structure */
  812.         emdp->token_tm = otimer;
  813.     }
  814.     else {
  815.         if (!memtest((long) sizeof(struct winds), "to make session")) {
  816.             return(-1);
  817.         }
  818.         otwp = emdp;
  819.         savecontext(emdp);
  820.         emdp = NewPtr((Size) (sizeof(struct winds))); 
  821.         if (emdp == NULL) {
  822.             emdp = otwp;
  823.             return(-1);
  824.         }
  825.         memzero(emdp, sizeof(struct winds));    
  826.             /* zero out the new structure */
  827.         
  828.         setcontext(emdp);
  829.  
  830.         if ((emdp->token_tm = tm_alloc()) == NULL) {
  831.             DisposPtr(emdp);
  832.             getcontext(otwp);
  833.             return(-1);
  834.         }
  835.     }
  836.     
  837.     emdp->emwindow = (WindowPtr) NULL;
  838.     emdp->iconwindow = (WindowPtr) NULL;
  839.     
  840.     emdp->savefid = 0;
  841.     emdp->gotoy = -1;
  842.  
  843.     emdp->cursorwait = TRUE;
  844.     ibmmode(FALSE);
  845.  
  846.     emdp->putchar = nullputchar;
  847.     emdp->putflush = nullputflush;
  848.     conns[conncount] = emdp;
  849.     conncount++;
  850.  
  851.     return(0);
  852.  
  853. }
  854.  
  855. /* destroy the most recent attempt to make a connection structure */
  856.  
  857. killconn()
  858. {
  859.     --conncount;
  860.     conns[conncount] = NULL;
  861.     if (keydp != NULL) {
  862.         DisposPtr(emdp);
  863.         setcontext(keydp);
  864.     }
  865.     else {
  866.         setcontext(conns[0]);
  867.     }        
  868. }
  869.  
  870.  
  871. /* standard close bottleneck call */
  872.  
  873. closeconn(twp)
  874. struct winds * twp;
  875. {
  876.     if (twp->connopen) {
  877.         getcontext(twp);
  878.         if (!hostclosemacro(twp->closemacro))
  879.             /* if there's no close macro, go ahead and close it up */
  880.             docloseconn();
  881.     }
  882. }
  883.  
  884. /* REALLY do a close on the emdp connection */
  885.  
  886. docloseconn()
  887. {
  888.     if (!emdp->connopen) {
  889.         return();
  890.     }
  891.     if (emdp->conntype == CONN_MACTCP) {
  892.         mactcp_close();
  893.     }
  894. #ifdef DUALTCP
  895.     else if (emdp->conntype == CONN_CUTCP) {
  896.         tcp_close();
  897.         emdp->ucb.u_state = CLOSING;
  898.         emdp->ucb.u_rstate = BLOCK;
  899.     }
  900. #endif
  901.     else if (emdp->conntype == CONN_SERD) {
  902.         windmenumark(emdp, noMark);        /* clear any marks */
  903.         closeserport(emdp);
  904.         cls_usr();            /* WARNING: twp may disappear, emdp may change! */
  905.     }
  906. }
  907.  
  908.  
  909. /* remove a connection from the table, we have no connection */
  910.  
  911. releaseconn(twp)
  912. struct winds * twp;
  913. {
  914.     register short count = 0;
  915.     
  916.     for (count = 0; count < conncount; count ++) {
  917.         if (twp == conns[count])
  918.             break;
  919.     }
  920.     if (count == conncount)
  921.         /* no such connection exists */
  922.         return(-1);
  923.     
  924.     /* we found a match, release resources associated with it */
  925.     if (twp->conntype == CONN_MACTCP) {
  926.         if (mactcpopen) {
  927.             tcp_release(twp);
  928.             tcpmemoryreclaim(twp);
  929.         }
  930.     }
  931. #ifdef DUALTCP
  932.     else if (twp->conntype == CONN_CUTCP) {
  933.         if (cutcpopen) {
  934.             /* TODO should we close down Cornell TCP completely to
  935.                 allow MacTCP to run? */
  936.             /* tcpemdp = NULL;        TODO this is improper! */
  937.             ;
  938.         }
  939.     }
  940. #endif
  941.     else if (twp->conntype == CONN_SERD) {
  942.         closeserport(twp);
  943.     }
  944.     
  945.     
  946.     if (conncount > 1) {
  947.         /* kill it */
  948.         
  949.         ascii_free(twp);                /* release any ASCII emulator memory */
  950.         ibm_free(twp);                /* release any IBM emulator memory */
  951.         tm_clear(twp->token_tm);
  952.         tm_free(twp->token_tm);
  953.         DisposPtr(twp);
  954.  
  955.         /* now shift down the other conns in the table */
  956.         for ( count++ ; count < conncount; count++) {
  957.             conns[count - 1] = conns[count];
  958.         }
  959.         
  960.         /* set the context to the first one */
  961.         if (twp == emdp ) {
  962.             /* the current context has been devastated */
  963.             emdp = NULL;            
  964.             getcontext(conns[0]);    /* set context to the first one in the table */
  965.         }
  966.         if (twp == keydp) {
  967.             /* if the context was the one on top--very likely--
  968.                 it exists no longer... */
  969.             keydp = NULL;
  970.             keywindow = NULL;
  971.         }
  972.     }
  973.     else {
  974.         /* leave one emdp struct around so
  975.             only 1 conn struct w/ no window exists */
  976.         
  977.         if (quitonclose)
  978.             /* user wants close when no windows/sessions exist */
  979.             cu_exit(0);
  980.             
  981.         connavailable = TRUE;    
  982.         setcontext(emdp);
  983.         
  984.         keydp = NULL;
  985.         keywindow = NULL;
  986.         
  987.         emedit(emdp, TRUE);
  988.         showcursor();                /* make sure cursor drawn */
  989.         /* TODO windows need to be reset and should the config be reset? */
  990.     }
  991.     --conncount;
  992.     conns[conncount] = NULL;
  993. }
  994.  
  995.  
  996. /* open a connection for a connection/window structure
  997.     must be in emdp context (using getcontext() or makeconn() )
  998. */
  999.  
  1000. openconn(twp)
  1001. struct winds * twp;
  1002. {
  1003.     unsigned sock;
  1004.  
  1005. #ifdef ARPFORHOST
  1006.     if (!at_arp(fhost.u.addr))
  1007.         return(-2);
  1008. #endif
  1009.  
  1010.     if (twp->connopen)
  1011.         return;
  1012.  
  1013. #ifdef MACTCP
  1014.     if (twp->conntype == CONN_CUTCP) {
  1015.         /* force it */
  1016.         twp->conntype = CONN_MACTCP;
  1017.     }
  1018. #endif
  1019.  
  1020.     if (twp->emwindow) {
  1021.         /* fix the window and menu */
  1022.         windmenumark(twp, noMark);        /* clear any marks */
  1023.         restore25();
  1024.     }
  1025.         
  1026.     if (twp->conntype == CONN_MACTCP
  1027.             || twp->conntype == CONN_CUTCP) {
  1028.         telnetreset(twp->termtype);
  1029.     }
  1030.                 
  1031.     if (twp->conntype == CONN_MACTCP 
  1032.         || macipopen && twp->conntype == CONN_CUTCP) {
  1033.         /* coerce MacTCP configuration if Cornell already started */
  1034.         
  1035.         extern int mactcp_put();
  1036.         extern int mactcp_ex();
  1037.  
  1038.         twp->conntype = CONN_MACTCP;
  1039.         
  1040.         twp->putchar = mactcp_put;
  1041.         twp->putflush = mactcp_ex;
  1042.         
  1043.         sock = tn_sock();
  1044.         if (twp->fhost.u.addr == -1L
  1045.             || twp->fhost.u.addr == 0L) {
  1046.                 /* avoid opening sessions to broadcast address, can
  1047.                     induce Cornell AT-GW to produce telnet storms... */
  1048.             error("Can't open Telnet session to the broadcast address; please reconfigure the session address");
  1049.         }
  1050.         else {
  1051.             pr25(0, hostwait);
  1052.             mactcp_open(&twp->fhost.u.addr, twp->fhost.port, sock);
  1053.         }
  1054.     }
  1055. #ifdef DUALTCP
  1056.     else if (twp->conntype == CONN_CUTCP) {
  1057.         extern int tc_put();
  1058.         extern int tcp_ex();
  1059.  
  1060.         if (tcpemdp == NULL) {
  1061.             /* add gateway address slot */
  1062.             tcpmenu();
  1063.         }
  1064.         else {
  1065.             if (tcpemdp->connopen) {
  1066.                 error("Only one Cornell TCP session can be used at a time");
  1067.                 return(-1);
  1068.             }
  1069.         }
  1070.  
  1071.         pr25(0, hostwait);
  1072.         twp->putchar = tc_put;
  1073.         twp->putflush = tcp_ex;
  1074.         
  1075.         tcpemdp = twp;
  1076.         if (!cutcpopen) {
  1077.             if (opensettings())
  1078.                 error("Can't open 'Comet Default' document");
  1079.                 
  1080.             
  1081.             tcp_init(0, tcpopn_usr, tcpwr_usr, tcpmst_run, 
  1082.                     tcpcls_usr, tcptmo_usr, tcppr_dot, tcpbfr);
  1083.         
  1084.             cutcpopen = TRUE;
  1085.             if (! (*rnet->n_subnet)()) {
  1086.                 if (get_subnet()) {
  1087.                     /* ignore lack of gateway, assume local net */
  1088.                     ;
  1089.                 }
  1090.                 else {
  1091.                     closesettings();
  1092.                     return(-1);
  1093.                 }
  1094.             }
  1095.             closesettings();
  1096.         }
  1097.         sock = tn_sock();
  1098.         tcp_open(&twp->fhost.u.addr, twp->fhost.port, sock);
  1099.     }
  1100. #endif
  1101.     else if (twp->conntype == CONN_SERD) {
  1102.         extern int serputchar();
  1103.         extern int serputflush();
  1104.         
  1105.         twp->putchar = serputchar;
  1106.         twp->putflush = serputflush;
  1107.         
  1108.         termreset();    /* clear the old screen */
  1109.         gettermtype();
  1110.         setcontext(emdp);
  1111.         
  1112.         setibm_keymode(twp->ibm_keymode);
  1113.             /* get controls now, whereas Telnet must wait until negotiations cease */
  1114.             
  1115.         if (openserport()) {
  1116.             pr25(0, nosessionstr);
  1117.             return(-1);
  1118.         }
  1119.         opn_usr();
  1120.         emdp->tndata = TRUE;            /* guarantee controls come up */
  1121.         hostconncomplete(emdp->connmacro);
  1122.     }
  1123.     return(0);
  1124. }
  1125.  
  1126.  
  1127.  
  1128. #define DLACCEPT     2000
  1129. #define DLACYES        1
  1130. #define DLACNO        2
  1131.  
  1132. int tftp_direction;
  1133.  
  1134. tntftp(host, file, dir)
  1135.     in_name host;
  1136.     char *file;
  1137.     unsigned dir; 
  1138. {
  1139.     char buffer[100];
  1140.     char c;
  1141.     short item;
  1142.     DialogPtr dptr;
  1143.     GrafPtr oldport;
  1144.  
  1145.     tftp_direction = dir;
  1146.     if (tftpask == TFNO) {
  1147.         mac_setdownvol();
  1148.         if (dir == PUT) {
  1149.             /* save the text window if necessary */
  1150.             textupedit(file);
  1151.         }
  1152.         return(TRUE);
  1153.     }
  1154.     else if (tftpask == TFYES) {
  1155. #ifdef BACKTFTPREJECT
  1156.         if (chkbackground())
  1157.             /* if asking on & we're in the background, reject the request */
  1158.             return(FALSE);
  1159. #endif
  1160.  
  1161.         if (host == emdp->fhost.u.addr) {
  1162.             ctop(file);
  1163.             HLock(emdp->hhostname);
  1164.             ParamText(*emdp->hhostname, dir == PUT ? "\Pread" : "\Pwrite", file, "\P");
  1165.             HUnlock(emdp->hhostname);
  1166.             ptoc(file);
  1167.         }
  1168.         else {
  1169.             sprintf(buffer, "%a", host);
  1170.             ctop(buffer);
  1171.             ctop(file);
  1172.             ParamText(buffer, dir == PUT ? "\Pread" : "\Pwrite", file, "\P");
  1173.             ptoc(file);
  1174.         }
  1175.         /* do dialog to determine if user will accept */
  1176.         GetPort(&oldport);
  1177.         emwdeactivate();
  1178.         
  1179.         SetDAFont(systemFont);
  1180.         if ( ( dptr = 
  1181.             GetNewDialog(DLACCEPT, (Ptr) NULL, (WindowPtr) -1) ) == NULL )
  1182.             return(FALSE);
  1183.  
  1184.         centerwind(dptr);
  1185.         SetPort(dptr);
  1186.         SetCursor(&arrow);        /* guarantee cursor is not blank */
  1187.         itemhighlight(dptr, 1);
  1188.  
  1189.         modaldialog = TRUE;
  1190.         while (TRUE) {
  1191. #ifdef MACTCP
  1192.             ModalDialog( (ProcPtr) NULL, &item);
  1193. #else
  1194.             extern Boolean alfilter();
  1195.             ModalDialog( (ProcPtr) alfilter, &item);
  1196. #endif
  1197.             switch (item) {
  1198.                 case DLACYES: {
  1199.                     DisposDialog(dptr);
  1200.                     SetPort(oldport);
  1201.                     modaldialog = FALSE;
  1202.                     mac_setdownvol();    /* fix the directory for multiple sessions */
  1203.                     if (dir == PUT)
  1204.                         textupedit(file);
  1205.                     return(TRUE);
  1206.                 }
  1207.                 case DLACNO: {
  1208.                     DisposDialog(dptr);
  1209.                     SetPort(oldport);
  1210.                     modaldialog = FALSE;
  1211.                     return(FALSE);
  1212.                 }
  1213.             }
  1214.         }
  1215.     }
  1216. }  
  1217.  
  1218.  
  1219.  
  1220.  
  1221. /*  function called when file transfer is done.  */
  1222.  
  1223. #define ALFTOK        2001
  1224. #define ALFTFAIL    2002
  1225.  
  1226. char transok[] = "File transferred OK\r";
  1227. char transfail[] = "File transfer FAILED\r";
  1228.  
  1229. tntfdn(success) 
  1230. int    success;
  1231. {
  1232.     extern char macfile[];            /* for tftp Macintosh file name translation */
  1233.  
  1234.     if (success)  {
  1235.         if (tftp_direction == GET) {
  1236.             textdownedit(&macfile[0]);
  1237.         }
  1238.     }
  1239.     else {
  1240.         fillwindow(COPYWINDOW, transfail, (long) strlen(transfail), systemFont, 12, 0L);
  1241.     }
  1242. }
  1243.  
  1244.  
  1245.  
  1246. itemhighlight(dlog, item)
  1247. DialogPtr dlog;
  1248. int item;
  1249. {
  1250.     short itemtype;
  1251.     Handle itemhand;
  1252.     Rect itemrect;
  1253.  
  1254.     GetDItem(dlog, (short) item, &itemtype, &itemhand, &itemrect);
  1255.     PenSize(3, 3);
  1256.     InsetRect(&itemrect, -4, -4);
  1257.     FrameRoundRect(&itemrect, 16, 16);
  1258. }
  1259.  
  1260. /* check to see if we have enough memory */
  1261.  
  1262. char * memstr = "Not enough memory ";
  1263.  
  1264. long memtest(amount, usererr)
  1265. long amount;
  1266. char * usererr;
  1267. {
  1268.     long free;
  1269.     char errstr[120];
  1270.     char * errp;
  1271.     
  1272.     if ( (free = FreeMem()) < amount + 15000) {
  1273.         strcpy(&errstr[0], memstr);
  1274.         if (usererr != NULL)
  1275.             strncat(&errstr[strlen(memstr)], usererr, 80);
  1276.         prerr25(&errstr[0]);
  1277.         return(0);
  1278.     }
  1279.     else
  1280.         return(free);
  1281. }
  1282.  
  1283.  
  1284.  
  1285. #ifdef MACTCP
  1286. /* define stubs for uncalled functions */
  1287.  
  1288. tcptmo_usr() 
  1289. {
  1290. }
  1291.  
  1292.  
  1293. tcpbfr() 
  1294. {
  1295. }
  1296.  
  1297. tcppr_dot()
  1298. {
  1299. }
  1300.  
  1301.  
  1302. datayield()
  1303. {
  1304. }
  1305.  
  1306. #else
  1307. tcptmo_usr() 
  1308. {
  1309.     error("Cannot reach host");
  1310.     tcpemdp->closeflag = TRUE;
  1311.     mtevent = TRUE;
  1312. }
  1313.  
  1314.  
  1315. tcpbfr() 
  1316. {
  1317.     if (tcpemdp->ucb.u_tcpfull) {
  1318.         tcpemdp->ucb.u_tcpfull = 0;
  1319.     }
  1320. }
  1321.  
  1322. tcppr_dot()
  1323. {
  1324. }
  1325.  
  1326.  
  1327. datayield()
  1328. {
  1329.     if (rnet->n_demux->ev_flg) {
  1330.         /* input q needs service */
  1331.         tkrun = rnet->n_demux;
  1332.         tk_yield();
  1333.     }
  1334. }
  1335.  
  1336. #endif
  1337.  
  1338. /* change controls & menus to reflect terminal we are emulating */
  1339.  
  1340. ibmmode(flag)
  1341. int flag;
  1342. {
  1343.     extern int ibmproc_token();
  1344.     extern int ibmsendchar();
  1345.     extern int ibmsendstr();
  1346.  
  1347.     extern int proc_token();
  1348.     extern int asciisendchar();
  1349.     extern int asciisendstr();
  1350.  
  1351.     emdp->ibm_mode = flag;
  1352.     
  1353.     /* select the token processor for handling user input */
  1354.     if (emdp->ibm_mode) {
  1355.         emdp->dotoken = ibmproc_token;
  1356.         emdp->sendchar = ibmsendchar;
  1357.         emdp->sendstr = ibmsendstr;
  1358.         
  1359.         /* TODO we need to reset the color map if it wasn't configured ... */
  1360.     }
  1361.     else {
  1362.         emdp->dotoken = proc_token;
  1363.         emdp->sendchar = asciisendchar;
  1364.         emdp->sendstr = asciisendstr;
  1365.     }
  1366. }
  1367.  
  1368.  
  1369. /* set up the controls and key resources for the emulator type 
  1370.     TODO could be more efficient if already set...
  1371. */
  1372.  
  1373. setibm_keymode(flag)
  1374. int flag;
  1375. {
  1376.     /* fix controls */
  1377.     
  1378.     reopenconfig(emdp);
  1379.  
  1380.     if (emwindow != NULL) {
  1381.         killcontrols(emwindow);
  1382.         controlinit(emwindow, flag ? IBMRES : ASCRES);
  1383.         
  1384.         /* do menu stuff */
  1385.         if (emdp == keydp) {
  1386.             if (keymenus(emdp))
  1387.                 DrawMenuBar();
  1388.         }
  1389.     }
  1390.     
  1391.     /* fix the key resources */
  1392.     keyxrelease();
  1393.     if (!emdp->newconf)
  1394.         keyxinit();
  1395.     closeconfig(emdp);
  1396.  }
  1397.  
  1398.  
  1399.  
  1400. #define MAXCLOSERS 30
  1401. static int (*closers[MAXCLOSERS])();
  1402. static int nclosers = 0;
  1403.  
  1404. exit_hook(func)
  1405.    int (*func)();
  1406. {
  1407.     if (nclosers < MAXCLOSERS)
  1408.         closers[++nclosers] = func;
  1409.     else
  1410.         error("out of exit_hooks");
  1411. }
  1412.  
  1413. cu_exit(arg)
  1414. int arg;
  1415. {
  1416.     int count;
  1417.  
  1418.     for(count = nclosers; count; count--)
  1419.         (*closers[count])();
  1420.     exit(arg);
  1421.       
  1422. }
  1423.  
  1424.  
  1425. /*    reset output context; most routines rely on the global emdp to 
  1426.     point to the current output window.  Several per-window variables
  1427.     are maintained also as globals to reduce overhead in the emulators
  1428.     and avoid modifying old code (zap esp.) to use emdp.
  1429.     
  1430.     It is crucial that the globals be maintained properly!
  1431. */
  1432.  
  1433. getcontext(conp)
  1434. struct winds * conp;
  1435. {
  1436.     if (conp == emdp) {
  1437.         /* save some time */
  1438.         if (emwindow) {
  1439.             /* guarantee at a minimum that port is set right */
  1440.             SetPort(emwindow);
  1441.         }
  1442.         return;
  1443.     }
  1444.     savecontext(emdp);
  1445.         /* save the old global context before the change */
  1446.     setcontext(conp);
  1447. }    
  1448.  
  1449.  
  1450. /* set the globals from a winds struct; set them all, since otherwise
  1451.     there might be a failure to save stuff during Telnet negotiations */
  1452.  
  1453. setcontext(conp)
  1454. register struct winds * conp;
  1455. {
  1456.     if (conp == NULL)
  1457.         return;
  1458.         
  1459.     if (conp->emwindow) {
  1460.         emwindow = conp->emwindow;
  1461.         SetPort(emwindow);                /* guarantee port is set right */
  1462.     }
  1463.     else 
  1464.         emwindow = NULL;
  1465.     
  1466.     emdp = conp;                    /* set the major league window structure * globals */
  1467.     
  1468.     thefont = conp->thefont;                        /* default font */
  1469.     startarr = conp->startarr;                        /* dsdraw -> array of ptrs to scanline starts */
  1470.     screenbytes = conp->screenbytes;                /* width of screen in bytes */
  1471.     screenrem = conp->screenrem;                    /* screenbytes - std screen */
  1472.     fontwidth = conp->fontwidth;
  1473.     
  1474.     xpos = conp->xpos;
  1475.     ypos = conp->ypos;                                /* current x, y position */
  1476.     modflg = conp->modflg;                            /* line modified bit array */
  1477.     clrflg = conp->clrflg;                            /* line cleared bit array */
  1478.  
  1479.     /* H19 vars */
  1480.     mode = conp->mode;                            /* interpretation mode of emulator */
  1481.     charp = conp->charp;                        /* ASCII -> cursor location in charr */
  1482.     attrib = conp->attrib;                        /* normal/reverse mode for copy drawing */
  1483.  
  1484.     wrap_around = conp->wrap_around;            /* normal/reverse mode for copy drawing */
  1485.     inserton = conp->inserton;                    /* insert mode */
  1486.     linelength = conp->linelength;                /* width of row */
  1487.     lastcol = conp->lastcol;                    /* linelength - 1 */
  1488.  
  1489.     /* vt100; preceeding are h19 vars also */
  1490.  
  1491.     vtmode = conp->vtmode;                        /* new mode holder for vt100 */
  1492.     argp = conp->argp;                            /* -> current argument */
  1493.  
  1494.     /* variables important to the 3270 interpreter */
  1495.     
  1496.     cmdstate = conp->cmdstate;                    /* state of the emulator */
  1497.     scr_map = conp->scr_map;                    /* 3270 screen map */
  1498.     smap_end = conp->smap_end;                    /* end of map */
  1499.     current_attr = conp->current_attr;          /* pointer to most recent attribute */
  1500.     cursor_ptr = conp->cursor_ptr;                /* current cursor position in screen map */
  1501.     firstp = conp->firstp;                        /* ptr to first data byte processed for set_map */
  1502. }
  1503.  
  1504. /*    
  1505.     restore output context:  save the globals which may have been modified for the
  1506.     next time around with this window
  1507. */
  1508.  
  1509. savecontext(conp)
  1510. register struct winds * conp;
  1511. {
  1512.  
  1513.     if (conp == NULL) 
  1514.         return;
  1515.     
  1516.     conp->xpos = xpos;
  1517.     conp->ypos = ypos;                        /* BIGG current x, y position */
  1518.     conp->modflg = modflg;                    /* BIGG line modified bit array */
  1519.     conp->clrflg = clrflg;                    /* BIGG line cleared bit array */
  1520.     
  1521.     /* h19 */
  1522.     conp->mode = mode;                        /* BIGG interpretation mode of emulator */
  1523.     conp->inserton = inserton;                /* BIGG insert mode */
  1524.     conp->attrib = attrib;                    /* BIGG normal/reverse mode for copy drawing */
  1525.     conp->wrap_around = wrap_around;        /* BIGG normal/reverse mode for copy drawing */
  1526.     conp->charp = charp;                    /* BIGG ASCII -> cursor location in charr */
  1527.  
  1528.     conp->linelength = linelength;            /* BIGG width of row */
  1529.     conp->lastcol = lastcol;                /* BIGG linelength - 1 */
  1530.  
  1531.     /* vt100 */
  1532.     conp->vtmode = vtmode;                    /* BIGG new mode holder for vt100 */
  1533.     conp->argp = argp;                        /* BIGG -> current argument */
  1534.  
  1535.     /* 3270 */
  1536.     conp->cmdstate = cmdstate;                /* BIGG state of the emulator */
  1537.     conp->scr_map = scr_map;                /* BIGG 3270 screen map */
  1538.     conp->smap_end = smap_end;                /* BIGG end of map */
  1539.     conp->current_attr = current_attr;      /* BIGG pointer to most recent attribute */
  1540.     conp->cursor_ptr = cursor_ptr;            /* BIGG current cursor position in screen map */
  1541.     conp->firstp = firstp;                    /* BIGG ptr to first data byte processed for set_map */
  1542.  
  1543. }    
  1544.  
  1545.  
  1546. /* We check instead to see if any data has arrived and upcall if so,
  1547.     and try to send things waiting on the queue */
  1548.  
  1549. short inio_service;
  1550.  
  1551. io_service()
  1552. {
  1553.     struct winds ** conp = conns;
  1554.     struct winds * conend = &conp[conncount];
  1555.     register struct winds * twp;
  1556.     int serialtime;
  1557.     
  1558.     if (inio_service)
  1559.         return;
  1560.     inio_service = TRUE;
  1561.     
  1562.     if (tickserial && cticks >= tickserial)
  1563.         serialtime = TRUE;
  1564.     else 
  1565.         serialtime = FALSE;
  1566.         
  1567.     /*  go through window list to see who needs service */
  1568. #ifdef TFTPSERVE
  1569.     if (tfsdata || tftpdata)
  1570.         /* MacTCP tftp service */
  1571.         tftp_upcall();
  1572. #endif
  1573.  
  1574.     if (mtevent) {
  1575.         mtevent = FALSE;        /* reset immediately after test: set asynchronously */
  1576.     }
  1577.     else if (serialtime) {
  1578.         tickserial = cticks + serialwait;
  1579.     }
  1580.     else {
  1581.         /* nothing happening, try to save time */
  1582.         inio_service = FALSE;
  1583.         return;
  1584.     }
  1585.     
  1586.     while (conp < conend) {
  1587.         twp = *conp++;
  1588.         if (twp == NULL)
  1589.             continue;
  1590.                 
  1591. #ifdef MAKEHYCCONN    
  1592.         if (twp->hycconnwait == TRUE) {
  1593.             /* if the API has requested an open, do it */
  1594.             /* use macro ? */
  1595.             twp->hycconnwait = 1;
  1596.             if (makeconn()) {
  1597.                 killconn();
  1598.                 continue;
  1599.             }
  1600.             getconfig();
  1601.             emdp->resfid = appresfid;
  1602.             emdp->resvol = appvol;
  1603.             emdp->resdir = appdir;
  1604.             
  1605.             keyxinit();
  1606.             makewind();
  1607.             openconn(emdp);
  1608.             continue;
  1609.         }
  1610. #endif
  1611.         if (twp->conntype == CONN_MACTCP) {
  1612.             /* has no new data... */
  1613.              if (! (twp->data_rcvd || twp->closeflag || twp->send_wait))
  1614.                 continue;
  1615.  
  1616.             /* reset output context */
  1617.             getcontext(twp);
  1618.             
  1619.             if (twp->data_rcvd) {
  1620.                 tcp_upcall();
  1621.                 twp->modflg = modflg;
  1622.                     /* update; could use savecontext() but not only modflg needed */
  1623.             }
  1624. #ifdef ASYNCOPEN
  1625.             if (!modaldialog && twp->openflag) {
  1626.                 opn_usr();
  1627.             }
  1628. #endif
  1629.             if (!modaldialog && twp->closeflag) {
  1630.                 /* don't EVER do this in the background, cls_usr may dialog */
  1631.                 mactcp_wrapup();    /* WARNING: twp may disappear, emdp may change! */
  1632.             }
  1633.             if (twp->send_wait) {
  1634.                 /* a packet is waiting for buffer; try to send again */
  1635.                 mactcp_ex();
  1636.             }
  1637.             else if (twp->fillcount && (twp->fillcount == twp->waitcount)) {
  1638.                 /* SHOULD NEVER REACH THIS POINT! symptom of 
  1639.                     MacTCP async "let's waste some variables" behavior */
  1640.                 prerr25("send_wait clobbered");
  1641.                 mactcp_ex();
  1642.             }
  1643.             continue;
  1644.         }
  1645. #ifdef DUALTCP
  1646.         else if (twp->conntype == CONN_CUTCP) {
  1647.             if (!modaldialog && twp->closeflag) {
  1648.                 /* close the session */
  1649.                 /* don't EVER do this in the background, cls_usr may dialog */
  1650.                 twp->closeflag = FALSE;
  1651.                 getcontext(twp);
  1652.                 windmenumark(twp, noMark);        /* clear any marks */
  1653.                 cls_usr();            /* WARNING: twp may disappear, emdp may change! */
  1654.             }
  1655.             continue;
  1656.         }
  1657. #endif
  1658.         else if (twp->conntype == CONN_SERD && serialtime) {
  1659.             /* check for serial data */
  1660.  
  1661.             getcontext(twp);
  1662.             serial_service();
  1663.             twp->modflg = modflg;
  1664.             continue;
  1665.         }
  1666.         else if (twp->conntype == CONN_COMMMGR) {
  1667.                 /* check for comm mgr data */
  1668.             ;
  1669.             continue;
  1670.         }
  1671.     }
  1672.     inio_service = FALSE;
  1673. }
  1674.  
  1675.  
  1676.  
  1677. nullputchar()
  1678. {
  1679. }
  1680.  
  1681. nullputflush()
  1682. {
  1683. }
  1684.  
  1685.  
  1686. /* called in the main user task to serve I/O while in dialog 
  1687.     or other modal situation */
  1688.  
  1689. bkrd_service()
  1690. {
  1691.     struct winds * oemdp;
  1692.     GrafPtr oport;
  1693.     
  1694.     oemdp = emdp;
  1695.     GetPort(&oport);
  1696.     
  1697.     token_service();    /* user output--handle actions waiting on the queue */
  1698.     io_service();        /* for merged MacTCP/CUTCP */
  1699. #ifdef DUALTCP
  1700.     tk_yield();            /* task yield for Cornell TCP */
  1701. #endif
  1702.     screen_service();    /* update screen */
  1703.     
  1704.     if (emdp != oemdp)
  1705.         /* restore the old context for all the callers out there */
  1706.         getcontext(oemdp);
  1707.     
  1708.     if (oport)
  1709.         SetPort(oport);     /* might not be emwindow */
  1710. }
  1711.  
  1712.  
  1713. /* turn the tftp server on
  1714. */
  1715.  
  1716. #define    OFF    0
  1717. #define    ON    1
  1718.  
  1719. tfs_on() 
  1720. {
  1721.     extern short tfstate;
  1722.  
  1723.     if (!tftpopen) {
  1724.         if (emdp->conntype == CONN_MACTCP) {
  1725.             if (mtcp_tfsinit(tntftp, tntfdn))
  1726.                 return(FALSE);
  1727.             tftpopen = TRUE;
  1728.         }
  1729. #ifdef DUALTCP
  1730.         else if (emdp->conntype == CONN_CUTCP) {
  1731.             if (tfsinit(tntftp, tntfdn))
  1732.                 return(FALSE);
  1733.             tftpopen = TRUE;
  1734.         }
  1735. #endif
  1736.     }
  1737.     tfstate = ON;
  1738.     return(TRUE);
  1739. }
  1740.  
  1741. /* turn the tftp server off
  1742. */
  1743.  
  1744. tfs_off() 
  1745. {
  1746.     extern short tfstate;
  1747.  
  1748.     tfstate = OFF;
  1749. }
  1750.  
  1751.  
  1752. /* set the name in the appfile struct used for document naming control */
  1753.  
  1754. setappfilename()
  1755. {
  1756.     register char * chp;
  1757.     register char * endp;
  1758.     register char * destp;
  1759.  
  1760.     /* copy the name into the appfile struct from hhostname;
  1761.         hhostname is a Pascal string */
  1762.     chp = *emdp->hhostname;
  1763.     endp = chp + **emdp->hhostname + 1;
  1764.     destp = &emdp->appfile.fName;
  1765.     
  1766.     while (chp < endp) {
  1767.         *destp++ = *chp++;
  1768.     }
  1769. }
  1770.  
  1771.  
  1772. istcptype()
  1773. {
  1774.     if (emdp->conntype == CONN_SERD || emdp->conntype == CONN_COMMMGR)
  1775.         return(FALSE);
  1776.     else
  1777.         return(TRUE);
  1778. }
  1779.  
  1780.  
  1781. /* added for compatibility with MPW */
  1782.  
  1783. SwapMMUMode(chararg)
  1784. Byte * chararg;
  1785. {
  1786. #asm
  1787.     move.l    8(a6),a0                    ; -> byte arg
  1788.     move.b    (a0),d0                        ; d0 = arg
  1789.     dc.w    $a05d                        ; _SwapMMUMode
  1790.     move.b    d0,(a0)                        ; return current mode in arg
  1791. #endasm
  1792. }
  1793.  
  1794. #ifndef DUALTCP
  1795.  
  1796. tcp_close()
  1797. {
  1798. }
  1799.  
  1800. DialogPtr nnrdptr;
  1801.  
  1802. shownnr()
  1803. {
  1804. }
  1805.  
  1806. hidennr()
  1807. {
  1808. }
  1809.  
  1810. #endif
  1811.  
  1812.  
  1813. invalidconn(twp)
  1814. struct winds * twp;
  1815. {
  1816.     register short count = 0;
  1817.     
  1818.     for (count = 0; count < conncount; count++) {
  1819.         if (twp == conns[count])
  1820.             return(0);
  1821.     }
  1822.     /* no such connection exists */
  1823.     return(-1);
  1824. }